home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr49 / 139_01.zip / KED2.C < prev    next >
Text File  |  1993-06-03  |  24KB  |  707 lines
  1. /*
  2. TITLE:        Karel The Robot;
  3. VERSION:    1.0;
  4. DATE:        09/27/1984;
  5. DESCRIPTION:
  6.     "Part 2 of source code for syntax-directed editor,
  7.      KED. Other functions.";
  8. KEYWORDS:    Editor, syntax;
  9. SYSTEM:        CP/M 2+;
  10. FILENAME:    KED2.C
  11. AUTHORS:    Linda Rising;
  12. COMPILERS:    BDS C;
  13. REFERENCES:
  14.     AUTHOR: Richard E. Pattis;
  15.     TITLE: "KAREL the Robot: A Gentle Introduction
  16.         to the Art of Programming";
  17.     CITATION: "";
  18. ENDREF
  19. */
  20.  
  21.  
  22. #include <bdscio.h>
  23. #include <ked.h>
  24.  
  25.  
  26. readin(w)   /* find location of command in comm array or symbol table */
  27. char w[];
  28. {
  29.           int c,i,l,m;
  30.  
  31.           do {
  32.             inputs(w);
  33.             if ((m = match(w,comm,MAXCOMM)) != NOMATCH)
  34.                return m;              
  35.             if (m == NOMATCH && last != first && p != pr) {
  36.                l = pr->lastin;
  37.                if (l == 15) 
  38.                    l = last;
  39.                for (i = first; i != l; i = new[i].nextin)
  40.                     if ((c = strcomp(w,new[i].defname)) == 0) 
  41.                        return ( -i - 1);
  42.             }          
  43.             printf("INVALID COMMAND. TYPE MN TO SEE MENU.\n?");
  44.           } while (m == NOMATCH);
  45. }
  46.  
  47.  
  48.  
  49. menu()           /* print updated menu */
  50. {
  51.           int i;
  52.  
  53.           printf("THE FOLLOWING IS A LIST OF VALID ");
  54.           printf("COMMANDS FOR THIS EDITOR.\n\n");
  55.           printf("  INSTRUCTIONS\n");   
  56.           printf("m          move\n");
  57.           printf("tl         turnleft\n");
  58.           printf("pi         pickbeeper\n");
  59.           printf("pu         putbeeper\n");
  60.           printf("to         turnoff\n");
  61.           printf("b          BEGIN\n");
  62.           printf("bx         BEGINNING-OF-EXECUTION\n");
  63.           printf("nd         END\n");
  64.           printf("ndc        end construct\n");
  65.           printf("ndx        END-OF-EXECUTION\n");
  66.           printf("if         IF\n");
  67.           printf("el         ELSE\n");
  68.           printf("it         ITERATE\n");
  69.           printf("wh         WHILE\n");
  70.           printf("df         DEFINE-NEW-INSTRUCTION\n");
  71.       printf("\nTYPE ANY KEY TO CONTINUE.\n");
  72.       getchar();
  73.           if (last != first) {   /* any valid sym tab entries? */
  74.            printf("\n  USER-DEFINED COMMANDS\n");
  75.            for (i = first; i != last; i = new[i].nextin)
  76.                 printf("%s\n", new[i].defname);  
  77.           }
  78.           printf("\n  EDIT COMMANDS\n");      
  79.           printf("n          move pointer to next instruction\n");
  80.           printf("nc         move pointer to next construct\n");
  81.           printf("n-         move pointer to previous instruction\n");
  82.           printf("n--        move pointer back 10 lines\n"); 
  83.           printf("d          delete current instruction\n");
  84.       printf("c          print current line\n");
  85.           printf("p          print next 20 lines\n");
  86.           printf("i          insert new instruction before current one\n");
  87.           printf("t          move pointer to the first line\n");
  88.           printf("l          list the rest of the program\n");
  89.           printf("s          save the program\n");
  90.           printf("mn         print an updated menu\n");
  91.           printf("q          quit the edit program\n");
  92.       printf("\nTYPE ANY KEY TO CONTINUE.\n");
  93.       getchar();
  94.           printf("\n  TESTS\n");
  95.           printf("n          facing-north\n");
  96.           printf("nn         not-facing-north\n");
  97.           printf("s          facing-south\n");
  98.           printf("ns         not-facing-south\n");
  99.           printf("e          facing-east\n");
  100.           printf("ne         not-facing-east\n");
  101.           printf("w          facing-west\n");
  102.           printf("nw         not-facing-west\n");
  103.           printf("c          next-to-a-beeper (beeper on corner)\n");
  104.           printf("nc         not-next-to-a-beeper\n");
  105.           printf("b          any-beepers-in-beeper-bag\n");
  106.           printf("nb         no-beepers-in-beeper bag\n");
  107.           printf("f          front-is-clear\n");
  108.           printf("nf         front-is-blocked\n");
  109.           printf("l          left-is-clear\n");
  110.           printf("nl         left-is-blocked\n");
  111.           printf("r          right-is-clear\n");
  112.           printf("nr         right-is-blocked\n");
  113. }
  114.  
  115. createtree()                      /* reads information from old file1 */
  116. {
  117.            int i,in,d,fn,fs,b,t,l;
  118.            struct tnode *alloc();
  119.  
  120.            fscanf(ibuf1, "%d %d %d %d %d %d %d %d",
  121.                   &i,&in,&d,&fn,&fs,&b,&t,&l);
  122.            pr = NULL;
  123.            p = alloc(24);                 
  124.            tree(i,in,d,fn,fs,b,t,l);              /* store first node */
  125.            root = p;
  126.            p = root->sub = alloc(24);
  127.            pr = root;
  128.            fscanf(ibuf1, "%d %d %d %d %d %d %d %d",
  129.                   &i,&in,&d,&fn,&fs,&b,&t,&l);
  130.            while (i != NDX && i != CPMEOF && i != EOF) { 
  131.                createnode(ibuf1,i,in,d,fn,fs,b,t,l);    
  132.                fscanf(ibuf1, "%d %d %d %d %d %d %d %d",
  133.                       &i,&in,&d,&fn,&fs,&b,&t,&l);
  134.            }
  135.            endcons();
  136.            tree(i,in,d,fn,fs,b,t,l);
  137.            pr = p;
  138.            fclose(ibuf1);        
  139. }
  140.  
  141.  
  142. createnode(ibuf1,i,in,d,fn,fs,b,t,l)    /* restores nodes for parse tree */
  143. FILE *ibuf1;
  144. int i,in,d,fn,fs,b,t,l;
  145. {
  146.           int j;
  147.           char w[MAXLINE];
  148.           struct tnode *allocp();
  149.  
  150.           if (d == NEWINSTR && pr->instr != DEF) {
  151.               i = reloc[i];                   /* set up array to convert */
  152.               j = 0;                              /* old symb tab to new */
  153.               while (new[i].loc[j] != NULL)
  154.                      j++;
  155.               new[i].loc[j] = p;
  156.               new [i].loc[++j] = NULL;
  157.           if (l != 15)
  158.          l = last;
  159.               tree(i,in,d,fn,fs,b,t,l);
  160.               p = p->next = allocp();
  161.           } else switch (i) { 
  162.                  case 0:            /* move */
  163.                  case 1:            /* turnleft */
  164.                  case 2:            /* pickbeeper */
  165.                  case 3:            /* putbeeper */
  166.                  case 4:            /* turnoff */
  167.                     while (in < pr->indent)
  168.                            endcons();
  169.             if (l != 15)
  170.                l = last;
  171.                     tree(i,in,d,fn,fs,b,t,l);
  172.                     p = p->next = allocp();
  173.                     break;
  174.                 case 5:             /* BEGIN */
  175.                 case 7:             /* BEGINNING-OF-EXECUTION */
  176.                 case 13:            /* ELSE */
  177.            if (l != 15)
  178.               l = last;
  179.                    tree(i,in,d,fn,fs,b,t,l);
  180.                    p = p->sub = allocp();
  181.                    break;
  182.                case 8:              /* END */
  183.           if (l != 15)
  184.              l = last;
  185.                   tree(i,in,d,fn,fs,b,t,l);
  186.                   p = p->next = allocp();
  187.                   endcons();
  188.                   break;
  189.                case 11:             /* IF */
  190.                   while (in < pr->indent)
  191.                       endcons();
  192.           if (l != 15)
  193.              l = last;
  194.                   tree(i,in,d,fn,fs,b,t,l);
  195.                   p = p->sub = allocp();
  196.                   fscanf(ibuf1,"%d %d %d %d %d %d %d %d",
  197.                          &i,&in,&d,&fn,&fs,&b,&t,&l);         /* get test */
  198.           if (l != 15)
  199.              l = last;
  200.                   tree(i,in,d,fn,fs,b,t,l);
  201.                   p = p->sub = allocp();
  202.                   fscanf(ibuf1, "%d %d %d %d %d %d %d %d",
  203.                          &i,&in,&d,&fn,&fs,&b,&t,&l);         /* get THEN */
  204.           if (l != 15)
  205.              l = last;
  206.                   tree(i,in,d,fn,fs,b,t,l);
  207.                   p = p->sub = allocp();
  208.                   break;
  209.                case 14:               /* ITERATE */
  210.                case 15:               /* WHILE */
  211.                   while (in < pr->indent)
  212.                       endcons();
  213.           if (l != 15)
  214.              l = last;
  215.                   tree(i,in,d,fn,fs,b,t,l);
  216.                   p = p->sub = allocp();
  217.                   fscanf(ibuf1,"%d %d %d %d %d %d %d %d",
  218.                          &i,&in,&d,&fn,&fs,&b,&t,&l);      /* get test or */
  219.           if (l != 15)                       /* pos int */
  220.              l = last;
  221.                   tree(i,in,d,fn,fs,b,t,l);                   
  222.                   p = p->sub = allocp();
  223.                   break;
  224.                case 16:             /* DEFINE-NEW-INSTRUCTION */
  225.                   tree(i,in,d,fn,fs,b,t,last);
  226.                   p = p->sub = allocp();
  227.                   fscanf(ibuf1,"%d %d %d %d %d %d %d %d",
  228.                          &i,&in,&d,&fn,&fs,&b,&t,&l);      /* get new name */
  229.                   i = reloc[i] = last;                        /* translate */
  230.                   j = 0;                              /* sym tab subscript */
  231.                   while ((w[j++] = getc(ibuf1)) != '\n')
  232.                       ;
  233.                   j -= 3;
  234.                   w[j] = '\0';
  235.                   strcpy(new[i].defname,w);
  236.                   new[i].nextin = last + 1; /* store next ref in sym table */
  237.                   tree(i,in,d,fn,fs,b,t,last);
  238.                   p = p->sub = allocp();
  239.                   break;
  240.                }
  241. }   
  242.  
  243.  
  244. insertinstr()     /* prepare to add instructions in insert mode */
  245. {
  246.     
  247.           struct tnode *allocp(), *conbegin();
  248.  
  249.           insert = 1;
  250.           insertnode = curr;
  251.           if ((curr->instr == NDX ||        /* find previous construct */
  252.                curr->instr == ND) && curr->del !=  NEWINSTR) {
  253.           p = curr->prev;
  254.           if (p->cons != 1)
  255.                  while (p->indent > curr->indent + 1)
  256.                      p = conbegin(p);
  257.           } else p = curr->prec;
  258.       if (p->instr == IFF) {     /* set THEN as start of construct */
  259.          p = advance(p);                /* so ELSE can be inserted */
  260.          p = advance(p);
  261.       }
  262.       ins = p->indent;       /* final indent level for construct */
  263.       if ((p->instr == BX || p->instr == BEG || p->instr == BEPGM)
  264.            && p->del != NEWINSTR)
  265.            ++ins;
  266.           if (insertnode == p->sub ||
  267.           (p->instr == BX && p->del != NEWINSTR)) 
  268.               p = p->sub = allocp();           /* set up links to next */
  269.           else {                                   /* node to be added */
  270.                p = p->next = allocp();
  271.            temp = insertnode->prev;  
  272.                temp->next = p;
  273.           }
  274. }
  275.  
  276.  
  277. endinsert()        /* exit insert mode */
  278. {
  279.           if (insert) {
  280.               if (pr->instr == THEN) 
  281.          if (p == pr->sub)
  282.             printf("PLEASE COMPLETE CONSTRUCT\n");
  283.              else endcons();
  284.               if (pr->indent > ins)
  285.                  printf("PLEASE COMPLETE CONSTRUCT\n");
  286.               else {
  287.                  insert = 0;
  288.                  insertnode->prec = pr;
  289.                  if (tempend != NULL) {            /* if a node has been */
  290.                      tempend->next = insertnode;   /* inserted link last */
  291.                      insertnode->prev = tempend;          /* instruction */
  292.                      tempend = NULL;
  293.                  } else if (temp != NULL)           /* otherwise restore */
  294.                             temp->next = insertnode;        /* old links */
  295.                         else if (p == pr->next)
  296.                                  pr->next = insertnode;
  297.                              else pr->sub = insertnode;
  298.                  temp = NULL;  
  299.                  free(p);
  300.                  p = pr;
  301.          curr = insertnode;
  302.               }
  303.          }
  304. } 
  305.  
  306.  
  307. delete()                /* delete or replace current instruction */
  308. {
  309.           int c;
  310.  
  311.           switch(curr->del) {
  312.           case 0:       /* reserved word */
  313.              printf("DELETE ENTIRE CONSTRUCT? (Y/N)\n");
  314.              if ((c = toupper(getchar())) == 'Y')
  315.                   deletecon();
  316.              else printf("\n");
  317.              break;
  318.           case 1:       /* simple instruction */
  319.              dealloc(curr,curr->next);
  320.              break;
  321.           case 2:       /* test */
  322.              prompt("TYPE REPLACEMENT ",1,"",5,0);
  323.              curr->instr = getest();
  324.              print(curr->prev,CONSOLE);
  325.              print(curr,CONSOLE);
  326.              break;
  327.           case 3:       /* positive number */
  328.              prompt("TYPE REPLACEMENT ",2,"",16,0);
  329.              curr->instr = getint();
  330.              print(curr->prev,CONSOLE);
  331.              print(curr,CONSOLE); 
  332.              break;
  333.           case 4:       /* new name */
  334.              if (curr->prev->instr == DEF) {
  335.                  prompt("TYPE REPLACEMENT ",4,"",9,0);
  336.                  getnew(curr->instr);
  337.                  print(curr->prev,CONSOLE);
  338.                  print(curr,CONSOLE); 
  339.              } else dealloc(curr,curr->next);
  340.              break;
  341.           case 5:       /* BEGINNING-OF-PROGRAM, BX, NDX */
  342.              printf("CAN'T BE DELETED\n?");
  343.              break;
  344.       }
  345. }
  346.  
  347.  
  348. deletecon()       /* locate start and end of current construct */
  349. {
  350.  
  351.           struct tnode *ptr1, *ptr2, *conbegin(), *conend();
  352.  
  353.           if (curr->instr == THEN || curr->cons != 1)
  354.               ptr1 = conbegin(curr);       /* locate start of construct */
  355.           else ptr1 = curr; 
  356.           if (ptr1->instr == DEF)          /* delete all references for */
  357.               deletenewin(ptr1->sub->instr);           /* defined instr */
  358.           ptr2 = conend(ptr1);               /* locate end of construct */
  359.           dealloc(ptr1,ptr2);
  360. }
  361.  
  362.  
  363. struct tnode *conbegin(ptr)       /* locates start of current construct */
  364. struct tnode *ptr;
  365. {
  366.           int in;
  367.  
  368.           if (ptr->instr == ND && ptr->del != NEWINSTR) {
  369.               in = ptr->indent;
  370.               while ((ptr = ptr->prev)->indent > in)
  371.                        ;
  372.           }
  373.           while ((ptr = ptr->prev)->cons != 1 || ptr->instr == THEN)
  374.              ;   
  375.           return ptr;
  376. }
  377.  
  378.  
  379. struct tnode *conend(ptr)        /* locates end of current construct */
  380. struct tnode *ptr;
  381. {
  382.  
  383.           int d,in;
  384.           struct tnode *advance();
  385.  
  386.           in = ptr->indent;
  387.       if (ptr != endof)
  388.              ptr = advance(ptr);
  389.           while (ptr != endof && (ptr->indent > in ||
  390.                  (d = ptr->del) == TEST || d == POSINT || d == NEWINSTR)) 
  391.               ptr = advance(ptr);
  392.           if (ptr == endof && (ptr->indent > in ||
  393.               (d = ptr->del) == TEST || d == POSINT || d == NEWINSTR))
  394.               ptr = p;
  395.           return ptr; 
  396.  
  397. }
  398.  
  399.  
  400. deletenewin(i)                /* removes user-defined instruction */
  401. int i;
  402. {
  403.  
  404.           int j;
  405.           struct tnode *ptr;
  406.  
  407.           j = 0;
  408.           while ((ptr = new[i].loc[j]) != NULL) { 
  409.               dealloc(ptr,ptr->next);        /* locate and delete */
  410.               j++;                                 /* uses in pgm */
  411.           }
  412.           j = first;
  413.           if (j != i) {
  414.              while (new[j].nextin != i)             /* remove sym */
  415.                  j = new[j].nextin ;          /* table references */
  416.              new[j].nextin = new[i].nextin;
  417.           } else if (new[first].nextin == last)
  418.                      --last;
  419.                  else first = new[i].nextin;
  420. }
  421.  
  422.  
  423.  
  424. dealloc(ptr1,ptr2)                 /* free space from ptr1 up to ptr2 */
  425. struct tnode *ptr1,*ptr2;
  426. {
  427.  
  428.           struct tnode *ptr;
  429.       
  430.           printf("\n");
  431.           if (ptr2->instr != NDX || ptr2->del == NEWINSTR)
  432.               ptr2->prec = ptr1->prec;        /* set up links between */
  433.           curr = ptr2;                        /* ptr2 & ptr1's parent */
  434.           ptr = ptr2->prev = ptr1->prev;
  435.           if (ptr1 == ptr->sub &&
  436.          (ptr2->instr != NDX || ptr2->del == NEWINSTR))
  437.               ptr->sub = ptr2;
  438.           else { 
  439.              ptr->next = ptr2;
  440.              if (ptr2->instr == NDX && ptr2->del != NEWINSTR)
  441.                  ptr->sub = NULL;
  442.           }
  443.           while (ptr1 != ptr2) {               /* deallocate nodes in */
  444.               ptr = ptr1;                     /* succession and print */
  445.               if (ptr1->sub != NULL)
  446.                   ptr1 = ptr1->sub;
  447.               else if (ptr1->next != NULL)
  448.                        ptr1 = ptr1->next;
  449.               print(ptr,CONSOLE);
  450.               free(ptr);  
  451.           }
  452.           if (ptr2 == p && p != pr) {              /* if last line of */
  453.               endof = temp = curr = ptr1->prev;   /* pgm, set new eof */ 
  454.               pr = ptr1->prec;
  455.               temp->next = p;
  456.           }       
  457. }
  458.  
  459.  
  460. putintable(i)     /* add new name to symbol table */
  461. int i;
  462. {
  463.           int j,k;
  464.  
  465.           if (insert && insertnode->instr == DEF) {
  466.               j = insertnode->sub->instr;         /* if inserting before */
  467.               new[i].nextin = j;                    /* DEF locate proper */
  468.               for (k = first; new[k].nextin != last;)     /* position in */
  469.                    k = new[k].nextin;                     /* linked list */
  470.               new[k].nextin = last + 1;
  471.               if (j == first)
  472.                   first = i;
  473.               else {
  474.                  for (k = first; new[k].nextin != j;)
  475.                       k = new[k].nextin;
  476.                  new[k].nextin = i;
  477.              }                            /* otherwise add as last entry */
  478.           } else new[i].nextin = last + 1;
  479. }   
  480.  
  481.  
  482. savetree(p,argv)         /* write parse tree to file1, text to file2 */
  483. struct tnode *p;
  484. char **argv;
  485. {
  486.           struct tnode *advance(); 
  487.  
  488.           fcreat(argv[1],ibuf1);         /* open both files */  
  489.           fcreat(argv[2],ibuf2);         /* for writing */
  490.           while (p != endof) {
  491.               fprintf(ibuf1, "%d %d %d %d %d %d %d %d \n",   /*codes */
  492.                     p->instr,p->indent,p->del,p->nfollow,/* in file1 */
  493.                     p->sfollow,p->comp,p->cons,p->lastin);
  494.               print(p,ibuf2);                       /* text in file2 */
  495.               if (p->instr == DEF && p->del == 0) {
  496.                   p = advance(p);
  497.                   fprintf(ibuf1,"%d %d %d %d %d %d %d %d \n",
  498.                           p->instr,p->indent,p->del,p->nfollow,
  499.                           p->sfollow,p->comp,p->cons,p->lastin);
  500.                   print(p,ibuf2);
  501.                   fprintf(ibuf1,"%s \n",new[p->instr].defname);
  502.               }             
  503.               p = advance(p);      
  504.            } 
  505.            fprintf(ibuf1, "%d %d %d %d %d %d %d %d \n",
  506.                    9,1,5,4,4,0,2,10);
  507.            print(p,ibuf2);
  508.            putc(CPMEOF,ibuf1);    putc(CPMEOF,ibuf2);
  509.            fclose(ibuf1);         fclose(ibuf2);
  510.          
  511. }
  512.  
  513.  
  514.  
  515. tree(i,in,d,fn,fs,b,t,l)    /* store instruction codes in parse tree */
  516. int i,in,d,fn,fs,b,t,l;
  517. {
  518.          p->sub = NULL;
  519.          p->next = NULL;
  520.          p->prec = pr;
  521.          if (pr->sub != NULL && p == pr->next) {
  522.              p->prev = temp;                       /* set up link to */
  523.              temp = NULL;                    /* previous instruction */
  524.          } else p->prev = pr;
  525.          p->instr = i;
  526.          p->indent = in;
  527.          p->del = d;
  528.          p->nfollow = fn;
  529.          p->sfollow = fs;
  530.          p->comp = b;
  531.          p->cons = t;
  532.          p->lastin = l;
  533.          if (insert)
  534.              tempend = p;     /* last node inserted */
  535.          else endof = p;      /* last node added (eof) */
  536. }
  537.  
  538.  
  539. struct tnode *allocp()      /* get space for next node */
  540. {
  541.           struct tnode *alloc(), *ptr;
  542.  
  543.           ptr = alloc(24);
  544.           curr = p;
  545.           pr = p;
  546.           return ptr;
  547. }
  548.  
  549.  
  550. inputs(w)         /* read in next command */
  551. char w[];
  552. {
  553.           int i,m;
  554.       char c;
  555.  
  556.       m = 0;
  557.           i = 0;
  558.           while ((c = w[i++] = tolower(getchar())) != '\n')
  559.               if ((c > 'z' || c < 'a') && (c > '9' || c < '0') && c != '-') 
  560.         m = ERROR;
  561.           w[--i] = '\0';
  562.       return m;
  563. }
  564.  
  565.  
  566. match(w,s,max)          /* compares string to array element */
  567. char w[], *s[];
  568. int max;
  569. {
  570.           int c,i;
  571.  
  572.           for (i = 0; i < max; i++) {
  573.             c = strcomp(w,s[i]);
  574.             if (c == 0)                 /* if match, return */
  575.                 return i;                /* array subscript */
  576.           }
  577.           return NOMATCH;            /* else return NOMATCH */
  578. }
  579.  
  580.  
  581. prompt(mess1,num1,mess2,num2,i)       /* prompt for next instruction */
  582. char *mess1,*mess2;
  583. int num1, num2,i;
  584. {
  585.           int j;
  586.  
  587.           printf("%s",mess1);                  /* print first string */
  588.           switch(num1) {           /* print desired instruction type */  
  589.           case 1:
  590.              printf("<test>");
  591.              break;
  592.           case 2:
  593.              printf("<positive-number>");
  594.              break;
  595.           case 3:
  596.              for (j = 0; j < curr->indent;
  597.                          printf("  "), j++);
  598.          if (i == ND || i == NDC) {
  599.         printf("\b");
  600.         printf("\b");
  601.          }
  602.              printf("<instruction>");
  603.              break;
  604.           case 4:
  605.              printf("<new-name>");
  606.              break;
  607.           }
  608.           printf("%s",mess2);            /* print second string */
  609.           for (; num2-- > 0; printf("\b"))
  610.             ;
  611. }
  612.  
  613.  
  614. struct tnode *advance(ptr)         /* point to next line or eof */
  615. struct tnode *ptr;
  616. {
  617.           if (ptr->sub != NULL)
  618.               ptr = ptr->sub;
  619.           else if (ptr->next != NULL)
  620.                    ptr = ptr->next;
  621.           return ptr;
  622. }
  623.  
  624.  
  625. checkin(valid)   /* correct location for an instruction? */
  626. int *valid;
  627. {
  628.           int in;
  629.  
  630.           *valid = 1;
  631.           if (p == pr && !insert) {  /* if NDX added, must insert */
  632.               printf("INSERT ONLY\n?");
  633.               *valid = 0;
  634.           } else { 
  635.                if (pr->instr == THEN && p!= pr->sub) {
  636.                    endcons();               /* end THEN construct */
  637.            if (insert)            /* since ELSE not added */
  638.               ins = pr->indent;
  639.            }
  640.                if (pr->nfollow == 0 &&           
  641.                           p == pr->next)
  642.                    in = pr->indent;         
  643.                else if (pr->sfollow == 0 && 
  644.                                p == pr->sub)
  645.                         in = pr->indent + 1;
  646.                      else { 
  647.                         *valid = 0;
  648.                         printf("BAD LOCATION FOR COMMAND. ");
  649.                         printf("TYPE MN TO SEE MENU.\n?");
  650.                      }
  651.             }           
  652.           return in;
  653. }
  654.  
  655.  
  656. checkcomp(valid)         /* compound statement? */
  657. int *valid;
  658. {
  659.           int b;
  660.  
  661.           if (pr->comp == 2) {       /* if 2nd instr added without BEGIN */
  662.               *valid = 0;
  663.               printf("STRUCTURE NOT A COMPOUND STATEMENT\n?");
  664.           } else if (pr->comp == 1)  /* if 1st instr added without BEGIN */
  665.                      b = 2;            /* set warning for future entries */
  666.                  else b = pr->comp;
  667.           return b;
  668. }
  669.  
  670.  
  671.  
  672. endcons()         /* end construct */
  673. {  
  674.           int in;
  675.           struct tnode *alloc();
  676.   
  677.           if (pr->indent == 1)     /* only BX, NDX indented 1 level */
  678.               printf("LAST POSSIBLE LEVEL\n");   
  679.           else {
  680.              if (temp->next != p     /* keep last instr in previous */
  681.          || temp == NULL)               
  682.            temp = pr;            /* construct if NDC repeated */
  683.              do {
  684.               in = pr->indent;
  685.               while ((pr = pr->prev)->cons != 1 /* go back to start */
  686.                       || pr->indent >= in);         /* of construct */
  687.              } while (pr->instr == ELS);               /* skip ELSE */
  688.              if (pr->instr == DEF)          /* if DEF ended add new */
  689.                  last++;                         /* name to sym tab */
  690.              pr->next = alloc(24);
  691.              free(p);
  692.              p = temp->next = pr->next;
  693.           } 
  694. }    
  695.  
  696.  
  697. strcomp(s1,s2)
  698. char s1[],s2[];
  699. {
  700.       int i;
  701.  
  702.       i = 0;
  703.       while (s1[i] == s2[i])
  704.          if (s1[i++] == '\0' || i == 8)
  705.         return 0;
  706.       return s1[i] - s2[i];
  707. }